package
{
	import flash.display.DisplayObject;
	import flash.events.EventDispatcher;
	import flash.system.*;
	import flash.utils.describeType;
	import flash.utils.getDefinitionByName;
	import flash.utils.getQualifiedClassName;
	import flash.utils.getQualifiedSuperclassName;
	
	import mx.collections.ArrayCollection;
	import mx.containers.Canvas;
	import mx.containers.FormItem;
	import mx.controls.*;
	import mx.core.ClassFactory;
	import mx.messaging.*;
	import mx.rpc.AbstractOperation;
	import mx.rpc.AsyncToken;
	import mx.rpc.events.*;
	import mx.rpc.http.mxml.HTTPService;
	import mx.rpc.remoting.*;
	import mx.utils.ObjectUtil;
	import mx.validators.NumberValidator;
	
	
	[Bindable]
	public dynamic class FlexFW extends EventDispatcher
	{
		public var objPadre:Object;
		public var remoteObject:RemoteObject;
		[Bindable]
		public var remoteHttp:HTTPService;
		public var objetosCreados:Array = new Array();
		private var _destination:String;
		public var trabajando:Boolean=false;
		public var tokenEnEspera:AsyncToken;
		public var arregloTipos:Array = new Array();
		[Bindable]
		public var lastSQL:String = "";
		public var tipoMotor:String = "";
		public var arrFunciones:Array = new Array();
		
		
		public function FlexFW(objPadre:Object,tipoMotor:String="SQLITE",replica:String="")
		{
			include "Configuration.as";
			super();
			this.objPadre = objPadre;
			this.tipoMotor = tipoMotor;
			switch(tipoMotor)
			{
				case "HTTP":
								var host:String = "";
								var metodo:String = "";
								for each(var e in Configuracion.Motor.(@tipo == "HTTP"))
									host = e.HOST;
									metodo = e.METHOD;
								constructorHTTP(host,metodo);
								break;
				case "SYNC":
								var host:String = "";
								var metodo:String = "";
								for each(var e in Configuracion.Motor.(@tipo == "SYNC"))
									host = e.HOST;
									metodo = e.METHOD;
								constructorSYNC(host,metodo);
								break;
				case "SQLITE":
								var host:String = "";
								for each(var e in Configuracion.Motor.(@tipo == "SQLITE"))
									host = e.HOST;
								//constructorSQLITE(host);
								break;
				case "MYSQL":
								//onstructorMYSQL();
								break;
				case "WEBORB":
								var host:String = "";
								for each(var e in Configuracion.Motor.(@tipo == "SQLITE"))
									host = e.HOST;
								constructorWEBORB(host);
								break;
			}
		}
		
		public function constructorHTTP(host:String,metodo:String):void
		{
			this.remoteHttp = new HTTPService();
			this.remoteHttp.url = host;
			this.remoteHttp.method = metodo;
			this.remoteHttp.resultFormat="text";
			this.remoteHttp.addEventListener(ResultEvent.RESULT, resultRemoteHttp);
			this.remoteHttp.addEventListener(FaultEvent.FAULT, showError);
		}
		
		public function constructorSYNC(host:String,metodo:String):void
		{

		}
				
		
		public function constructorWEBORB(destination:String)
		{
			remoteObject = new RemoteObject();
   			remoteObject.destination = this.destination = destination;
   			remoteObject.addEventListener("fault", showError);
		}
		
		

		
		public function metaTipos(arreglo:Array,tabla:String):Array
		{
			var arrSalida:Array = new Array();
			for( var i:int=0; i < this.arregloTipos[tabla].length; i++ )
			{
				if(arreglo.hasOwnProperty(arregloTipos[tabla][i].name))
				{
					arrSalida[arregloTipos[tabla][i].name] = arregloTipos[tabla][i].dataType;
				}
			}
			return arrSalida;
		}
		
		public function valida(tipo:String,valor:String):String
		{
			var caracter:String = "";
			var numero:Number;
			switch (tipo)
			{
				case "TEXT":
				case "Text":
				case "s":
					caracter = "'";
					valor = valor.toUpperCase();
				break;
				case "INTEGER":
				case "Integer":
				case "i":
					caracter = "'";
					valor = valor.replace(",","");
					numero = int(valor);
					if(!(numero is int))
						valor = "NULL";
					else
						valor = numero.toString();
				break;
				case "REAL":
				case "Real":
				case "f":
					caracter = "'";
					valor = valor.replace(",","");
					numero = Number(valor);
					if(!(numero is Number && numero))
						valor = "NULL";
					else
						valor = numero.toString();
				break;
				case "DATE":
				case "Date":
				case "d":
					caracter = "'";
					valor = valor.substr(6,4) + "-" + valor.substr(3,2) + "-" + valor.substr(0,2);
				break;
				default:
					caracter = "'";
				break;
			}
			return caracter + valor + caracter;
		}
		
		public function obtenCampoId(tabla:String):String
		{
			for( var i:int=0; i < this.arregloTipos[tabla].length; i++ )
			{
				if( arregloTipos[tabla][i].primaryKey )
					return arregloTipos[tabla][i].name;
			}
			return "";
		}
		
		public function arrayNotBlank(arreglo:Array):Array
		{
			var salida:Array = new Array();
			for( var j:String in arreglo )
			{
				if( arreglo[j] != "" )
				{
					salida[j] = arreglo[j];
				}
			}
			return salida.valueOf();
		}
		
		public function esTabla(tabla:String):Boolean
		{
			if( arregloTipos.hasOwnProperty(tabla) )
				return true;
			return false; 
		}
		
		public function strContiene(cadena:String,buscar:String):Boolean
		{
			if( cadena.indexOf(buscar) != -1 )
				return true;
			return false;
		}
		
		public function arrayLength(arreglo:Array):int
		{
			var cont:int = 0;
			for(var j:String in arreglo)
			{
				cont++;
			}
			return cont;
		}

		
		public function combo(tabla:String,campo:String,valor:String,campoFiltro:String="",valorFiltro:String=""):Array
		{
			var salida:Array= new Array();
			var extra:String = "";
			var renglones:Array;
			if(campoFiltro)
				extra = " WHERE " + campoFiltro + "='" + valorFiltro + "'";
			var sql:String = "SELECT DISTINCT " + valor + "," + campo + " FROM " + tabla + extra;
			this.ejecutar(sql);
			renglones = this.arrayNotBlank(this.resultado.data);
			for(var indice:String in renglones)
				salida.push({label:renglones[indice][campo],data:renglones[indice][valor]});
			return salida;
		}

		
		public function crearCondicional(campo:String,valor:String):String
		{
			var salida:String = "";
			if( this.strContiene(valor,"<") || this.strContiene(valor,">") || this.strContiene(valor,"=") || this.strContiene(valor,"not ") || this.strContiene(valor,"is ") || this.strContiene(valor,"NOT ") || this.strContiene(valor,"IS ") || this.strContiene(valor,"LIKE ") || this.strContiene(valor,"like ") )
				salida = campo+" "+valor;
			else 
			{
				if( this.strContiene(valor,"(") || this.strContiene(valor,")") )
					salida = campo+" = " +valor;
				else 
					salida = campo+" = '"+this.checa(valor)+"'";
			}
			return salida;
		}
		
		public function checa(valor:String):String
		{
			return valor.replace("'",'\"');
		}
		
		public function contOp(valor:String):Boolean
		{
			if( this.strContiene(valor,"<") || this.strContiene(valor,">") || this.strContiene(valor,"=") || this.strContiene(valor,"not ") || this.strContiene(valor,"is ") || this.strContiene(valor,"NOT ") || this.strContiene(valor,"IS ") || this.strContiene(valor,"LIKE ") || this.strContiene(valor,"like ") )
				return true;
			return false;
		}
		
		public function arregloValido(arreglo:Array,tabla:String):Array
		{
			var arrSalida:Array = new Array();
			for( var i:int = 0; i < arregloTipos[tabla].length ; i++ )
			{
				if( arreglo.hasOwnProperty( arregloTipos[tabla][i].name ) )
				{
					arrSalida[ arregloTipos[tabla][i].name ] = arreglo[ arregloTipos[tabla][i].name ] ;
				}
			}
			return arrSalida.valueOf();
		}

		
		
		
		private function showError(event:FaultEvent):void
		{
			Alert.show(event.fault.faultString, 'Error');
		}
		
		public function addMetodos(arregloMetodoFuncion:Array):FlexFW
		{
			var funcion:Function
			for(var i:int = 0;i<arregloMetodoFuncion.length;i++)
			{
				var nombreMetodo:String = arregloMetodoFuncion[i][0];
				
					
				if(arregloMetodoFuncion[i][1]!=null)
					funcion = arregloMetodoFuncion[i][1];
				else
					funcion = 
					function(event:ResultEvent):void
					{
						Alert.show(event.result.toString());
					};
				if( this.tipoMotor == "WEBORB" )
				{
					remoteObject.getOperation(arregloMetodoFuncion[i][0]).addEventListener(
																		ResultEvent.RESULT,
																		funcion
																		);
				}
				this.arrFunciones[arregloMetodoFuncion[i][0]] = funcion;
			}
			return this;
		}
		

		public function addMetodo(funcionRemota:String,funcionResult:Function=null):AbstractOperation
		{
			var funcion:Function
			if(funcionResult!=null)
				funcion = funcionResult;
			else
				funcion = 
				function(event:ResultEvent):void
				{
					Alert.show(event.result.toString());
				};
			remoteObject.getOperation(funcionRemota).addEventListener(
																	ResultEvent.RESULT,
																	funcion
																	);
			return remoteObject.getOperation(funcionRemota);
		}
		
		
		function ejecutarHttp(accion:String, ... args):AsyncToken
		{
			var numParam:int = 1;
			var objEnviar:Object = new Object();
			var tiempo:Date = new Date();
			objEnviar["t"] = tiempo.getTime().toString();
			objEnviar["a"] = accion;
			for each(var obj:* in args)
			{
				objEnviar["p["+(numParam++).toString()+"]"] = Serializer.serialize( obj );
			}
			return this.remoteHttp.send(objEnviar);
		}

	
		public function resultRemoteHttp(event:ResultEvent):void
		{
			var obj:* = Serializer.unserialize( event.result.toString() );
			if( obj )
			{
				if( obj.hasOwnProperty("funcion") )
				{
					if( this.arrFunciones.hasOwnProperty( obj["funcion"] ) )
					{
						var funcion:Function = this.arrFunciones[ obj["funcion"] ];
						funcion.call(this,obj["data"]);
					}
					else
					{
						this.varDump( obj["data"] );
					}
				}
			}
		}
	

		public function resultMetodo(nombreMetodo:String):Object
		{
			var objeto:Object = remoteObject.getOperation(nombreMetodo).lastResult;
			Alert.show(nombreMetodo);
			return objeto;
		}
		
		
		public function removeMetodo(funcionRemota:String,funcionResult:Function):FlexFW
		{
			remoteObject.getOperation(funcionRemota).removeEventListener(ResultEvent.RESULT,funcionResult);
			return this;
		}
		
		public function changeMetodo(funcionRemota:String,funcionResult:Function):AbstractOperation
		{
			removeMetodo(funcionRemota,funcionResult);
			addMetodo(funcionRemota,funcionResult);
			return remoteObject.getOperation(funcionRemota);
		}
		
		
		/*
		* Se ingresa en el primer parametro un objeto de tipo container Canvas,Form,WindowApplication,Application,etc
		* Devuleve en un objeto los elementos que encontro usando como nombre de atributo el id de cada campo contenido
		* en el contenedor, y cada uno tomando como valor el valor correspondiente al campo.
		* [objeto] El segundo parametro es un objeto ya existente que necesita ser rellenado, es decir ya tiene atributos y en 
		* base a los atributos que contenga son los que seran rellenados.
		*/
		public function forma2Object(contenedor:Object,objeto:Object=null):Object
		{
			//if(getQualifiedSuperclassName(contenedor).indexOf("ontainer")||getQualifiedClassName(contenedor).indexOf("ontainer")||getQualifiedSuperclassName(contenedor).indexOf("pplication")||getQualifiedClassName(contenedor).indexOf("pplication")){
				var arreglo:Array = new Array();;
				var arrControles:Array = contenedor.getChildren();
				var i:int;
						
				if(objeto!=null)
				{
					if(getQualifiedClassName(objeto)=="String")
					{
						if(!ApplicationDomain.currentDomain.hasDefinition(objeto.toString()))
							return forma2Object(contenedor);
						var Clase:Class = getDefinitionByName(objeto.toString()) as Class;
						var generador:ClassFactory = new ClassFactory(Clase);
						var objetoClase:Object = generador.newInstance();
			
						for(i=0;i<arrControles.length;i++)
							if(objetoClase.hasOwnProperty(arrControles[i].id))
								arreglo[arrControles[i].id] = valorDe(arrControles[i]);
						
						generador.properties = arreglo;
						return generador.newInstance();
					}
					else
					{
			
						for(i=0;i<arrControles.length;i++)
							if(objeto.hasOwnProperty(arrControles[i].id))
								objeto[arrControles[i].id] = valorDe(arrControles[i]);
						
						return objeto;
					}
				}
				else
				{
						var nombreClase:String = contenedor.name!=""?contenedor.name:contenedor.id;
						var objetoNuevo:DynamicClase = new DynamicClase(nombreClase);
						var cont:int = 0;
						
						for(i=0;i<arrControles.length;i++)
							if(arrControles[i].name!="")
							{
								objetoNuevo[arrControles[i].name] = valorDe(arrControles[i]);
								cont++;
							}
								
						if(cont==0)
						{
							for(i=0;i<arrControles.length;i++)
								objetoNuevo[arrControles[i].id] = valorDe(arrControles[i]);
						}
						
						return objetoNuevo;
				}
			
			return objeto;
		}
		
		
		
		
		/*
		*	Recibe un arreglo de objetos y los transforma en un objeto con los indices de cada objeto contenido en el 
		* 	arreglo asi como su valor.
		*	contenedor - Es un arreglo de objetos
		* 	[objeto] - Es un objeto existente que ya contiene atributos y espera ser rellenado
		*/
		public function element2Object(contenedor:Object,objeto:Object=null):Object
		{
			//if(getQualifiedSuperclassName(contenedor).indexOf("ontainer")||getQualifiedClassName(contenedor).indexOf("ontainer")||getQualifiedSuperclassName(contenedor).indexOf("pplication")||getQualifiedClassName(contenedor).indexOf("pplication")){
				var arreglo:Array = new Array();
				var arrElem:Array = new Array();
				var tipoElem:String = "";
				if(contenedor.hasOwnProperty("selectedItem"))
				{
					tipoElem = contenedor.name!=""?contenedor.name:contenedor.id;
					if(contenedor.selectedItem!=null)
						arrElem = objeto2Array(contenedor.selectedItem);
					else
						return false;
				}
				else
				{
					arrElem = objeto2Array(contenedor);
				}
				var i:int;
				var j:String;
						
				if(objeto!=null)
				{
					if(getQualifiedClassName(objeto)=="String")
					{
						if(!ApplicationDomain.currentDomain.hasDefinition(objeto.toString()))
							return element2Object(contenedor);
						var Clase:Class = getDefinitionByName(objeto.toString()) as Class;
						var generador:ClassFactory = new ClassFactory(Clase);
						var objetoClase:Object = generador.newInstance();
			
						for(j in arrElem)
							if(objetoClase.hasOwnProperty(j))
								arreglo[j] = arrElem[j];
						
						generador.properties = arreglo;
						return generador.newInstance();
					}
					else
					{
			
						for(j in arrElem)
							if(objeto.hasOwnProperty(j))
								objeto[j] = arrElem[j];
						
						return objeto;
					}
				}
				else
				{
					
					tipoElem = tipoElem!=""?tipoElem:"DynamicClase";
					var objetoNuevo:DynamicClase = new DynamicClase(tipoElem);
							
					for(j in arrElem)
						objetoNuevo[j] = arrElem[j];
							
					return objetoNuevo;
							
				}
			
			return objeto;
		}
		
		
		/*
		*	Convierte un arreglo en un objeto
		*	arrElem - Es un array o ArrayCollection
		* 	[objeto] - Es un objeto existente que ya contiene atributos y espera ser rellenado
		*/
		public function array2Object(arrElem:Object,objeto:Object=null):Object
		{
			//if(getQualifiedSuperclassName(contenedor).indexOf("ontainer")||getQualifiedClassName(contenedor).indexOf("ontainer")||getQualifiedSuperclassName(contenedor).indexOf("pplication")||getQualifiedClassName(contenedor).indexOf("pplication")){
				var arreglo:Array = new Array();
				var tipoElem:String = arrElem["nombreClase"];
				var i:int;
				var j:String;
						
				if(objeto!=null)
				{
					if(getQualifiedClassName(objeto)=="String")
					{
						if(!ApplicationDomain.currentDomain.hasDefinition(objeto.toString()))
							return array2Object(arrElem);
						var Clase:Class = getDefinitionByName(objeto.toString()) as Class;
						var generador:ClassFactory = new ClassFactory(Clase);
						var objetoClase:Object = generador.newInstance();
			
						for(j in arrElem)
							if(objetoClase.hasOwnProperty(j))
								arreglo[j] = arrElem[j];
						
						generador.properties = arreglo;
						return generador.newInstance();
					}
					else
					{
			
						for(j in arrElem)
							if(objeto.hasOwnProperty(j))
								objeto[j] = arrElem[j];
						
						return objeto;
					}
				}
				else
				{
					
					tipoElem = tipoElem!=""?tipoElem:"DynamicClase";
					var objetoNuevo:DynamicClase = new DynamicClase(tipoElem);
							
					for(j in arrElem)
						objetoNuevo[j] = arrElem[j];
							
					return objetoNuevo;
							
				}
			
			return objeto;
		}
		
		
		/*
		*	Regresa el valor de un componente, de una coleccion o de un objeto
		*	objeto - Objeto al cual deseas obtener su valor
		*	[separador] - En una coleccion, se toma este caracter para separar los valores
		*/
		public function valorDe(objeto:Object,separador:String="|"):Object
		{
			var arrSalida:Array;
			var cadSalida:String = "";
			var i:String;
			switch(getQualifiedClassName(objeto))
			{
				case "mx.containers::FormItem":
					var objFormItem:FormItem = objeto.valueOf();
					return valorDe(objFormItem.getChildAt(0));
					
				case "mx.containers::Canvas":
					var objCanvas:Canvas = objeto.valueOf();
					return valorDe(objCanvas.getChildAt(0));
					
				case "mx.controls::TextInput":
					var objTextInput:TextInput = objeto.valueOf();
					return objTextInput.text as Object;
					
				case "mx.controls::ComboBox":
					var objComboBox:ComboBox = objeto.valueOf();
					return objComboBox.selectedItem.data as Object;
					
				case "mx.controls::ColorPicker":
					var objColorPicker:ColorPicker = objeto.valueOf();
					return objColorPicker.selectedColor.toString() as Object;
					
				case "mx.controls.:HorizontalList":
					var objHorizontalList:HorizontalList = objeto.valueOf();
					arrSalida = objHorizontalList.selectedItems;
					for(i in arrSalida)
					 cadSalida += i=="0"?"":separador + arrSalida[i].data;
					return cadSalida as Object;
					
				case "mx.controls::List":
					var objList:List = objeto.valueOf();
					arrSalida = objList.selectedItems;
					for(i in arrSalida)
					 cadSalida += i=="0"?"":separador + arrSalida[i].data;
					return cadSalida as Object;
					
				case "mx.controls::NumericStepper":
					var objNumericStepper:NumericStepper = objeto.valueOf();
					return objNumericStepper.value as Object;
					
				case "mx.controls::ProgressBar":
					var objProgressBar:ProgressBar = objeto.valueOf();
					return objProgressBar.value as Object;
							
				case "mx.controls::TabBar":
					var objTabBar:TabBar = objeto.valueOf();
					return objTabBar.selectedIndex as Object;
					
				case "mx.controls::TileList":
					var objTileList:TileList = objeto.valueOf();
					arrSalida = objTileList.selectedItems;
					for(i in arrSalida)
					 cadSalida += i=="0"?"":separador + arrSalida[i].data;
					return cadSalida as Object;
					
				case "mx.controls::Tree":
					var objTree:Tree = objeto.valueOf();
					arrSalida = objTree.selectedItems;
					for(i in arrSalida)
					 cadSalida += i=="0"?"":separador + arrSalida[i].data;
					return cadSalida as Object;
					
				case "mx.controls::VSlider":
					var objVSlider:VSlider = objeto.valueOf();
					return objVSlider.value as Object;
					
				case "mx.controls::HSlider":
					var objHSlider:HSlider = objeto.valueOf();
					return objHSlider.value as Object;	
				
				case "mx.controls::VScrollBar":
					var objVScrollBar:VScrollBar = objeto.valueOf();
					return objVScrollBar.scrollPosition as Object;
					
				case "mx.controls::HScrollBar":
					var objHScrollBar:HScrollBar = objeto.valueOf();
					return objHScrollBar.scrollPosition as Object;
					
				case "mx.controls::ButtonBar":
					var objButtonBar:ButtonBar = objeto.valueOf();
					return objButtonBar.selectedIndex as Object;
					
				case "mx.controls::ToggleButtonBar":
					var objToggleButtonBar:ToggleButtonBar = objeto.valueOf();
					return objToggleButtonBar.selectedIndex as Object;	
					
				case "mx.controls::CheckBox":
					var objCheckBox:CheckBox = objeto.valueOf();
					return objCheckBox.selected as Object;	
					
				case "mx.controls::PopUpButton":
					var objPopUpButton:PopUpButton = objeto.valueOf();
					return objPopUpButton.selectedField as Object;
					
				case "mx.controls::RadioButton":
					var objRadioButton:RadioButton = objeto.valueOf();
					return objRadioButton.selectedField as Object;		
					
				case "mx.controls::RadioButtonGroup":
					var objRadioButtonGroup:RadioButtonGroup = objeto.valueOf();
					return objRadioButtonGroup.selectedValue as Object;	
					
				case "mx.controls::DateChooser":
					var objDateChooser:DateChooser = objeto.valueOf();
					return objDateChooser.selectedDate.toTimeString() as Object;		
					
				case "mx.controls::DateField":
					var objDateField:DateField = objeto.valueOf();
					return objDateField.selectedDate.toTimeString() as Object;	
					
				case "mx.controls::Label":
					var objLabel:Label = objeto.valueOf();
					return objLabel.text as Object;
					
				case "mx.controls::RichTextEditor":
					var objRichTextEditor:RichTextEditor = objeto.valueOf();
					return objRichTextEditor.htmlText as Object;
					
				case "mx.controls::Text":
					var objText:Text = objeto.valueOf();
					return objText.text as Object;
					
				case "mx.controls::TextArea":
					var objTextArea:TextArea = objeto.valueOf();
					return objTextArea.text as Object;
					
				case "mx.controls::DataGrid":
					var objDataGrid:DataGrid = objeto.valueOf();
					return objDataGrid.dataProvider as Object;
					
												
					
				default:
					return null;
			}
		}
		
		
		/*
		*	Asigna el valor deseado a un objeto, coleccion o componente dado.
		*	objeto - Objeto al cuals e le asignara el valor
		*	valor - Cualquier valor que pueda recibir ese campo
		*	[debug] - boolean, activa el mostrar errores en caso de haber ingresado un valor que no es compatible
		*	[extra] - Separador que se usa solo en las colecciones
		*/
		public function asignarValor(objeto:Object,valor:Object="",debug:Boolean=false,extra:String=""):Boolean
		{
			
			switch(getQualifiedClassName(objeto))
			{
				case "mx.containers::FormItem":
					var objFormItem:FormItem = objeto.valueOf();
					asignarValor(objFormItem.getChildAt(0),valor,debug);
					break;
				case "mx.containers::Canvas":
					var objCanvas:Canvas = objeto.valueOf();
					asignarValor(objCanvas.getChildAt(0),valor,debug);
					break;
				case "mx.controls::TextInput":
					var objTextInput:TextInput = objeto.valueOf();
					debug?debugAlert(objeto,valor,objTextInput.text):"";
					objTextInput.text = valor.valueOf();
					break;
				case "mx.controls::ComboBox":
					var objComboBox:ComboBox = objeto.valueOf();
					debug?debugAlert(objeto,valor,objComboBox.selectedItem," debes ingresar un dato en este formato numero string o \{ label:valor1 \} o \{ data:valor1 \} o \{ label:valor1 , data:valor2  \}"):"";
					if(extra)
						listaValor(objComboBox,valor,extra);
					else
						listaValor(objComboBox,valor);
					break;
					
				case "mx.controls::ColorPicker":
					var objColorPicker:ColorPicker = objeto.valueOf();
					debug?debugAlert(objeto,valor,objColorPicker.selectedColor,"debes ingresar un dato en el siguiente formato 0x336699"):"";
					objColorPicker.selectedColor = valor.valueOf();
					break;
				case "mx.controls::HorizontalList":
					var objHorizontalList:HorizontalList = objeto.valueOf();					
					debug?debugAlert(objeto,valor,objHorizontalList.selectedItem):"";
					listaValor(objHorizontalList,valor);
					break;
				case "mx.controls::List":
					var objList:List = objeto.valueOf();					
					debug?debugAlert(objeto,valor,objList.selectedItem):"";
					listaValor(objList,valor);
					break;
				case "mx.controls::NumericStepper":
					var objNumericStepper:NumericStepper = objeto.valueOf();
					debug?debugAlert(objeto,valor,objNumericStepper.value):"";
					objNumericStepper.value = valor.valueOf();
					break;
				case "mx.controls::ProgressBar":
					var objProgressBar:ProgressBar = objeto.valueOf();
					debug?debugAlert(objeto,valor,objProgressBar.value):"";
					objProgressBar.setProgress(valor[0].valueOf(),valor[1].valueOf());
					break;		
				case "mx.controls::TabBar":
					var objTabBar:TabBar = objeto.valueOf();					
					debug?debugAlert(objeto,valor,objTabBar.selectedIndex):"";
					objTabBar.selectedIndex = valor.valueOf();
					break;
				case "mx.controls::TileList":
					var objTileList:TileList = objeto.valueOf();					
					debug?debugAlert(objeto,valor,objTileList.selectedItem):"";
					listaValor(objTileList,valor);
					break;
				case "mx.controls::Tree":
					var objTree:Tree = objeto.valueOf();
					debug?debugAlert(objeto,valor,objTree.selectedItem):"";
					listaValor(objTree,valor);
					break;
				case "mx.controls::VSlider":
					var objVSlider:VSlider = objeto.valueOf();
					debug?debugAlert(objeto,valor,objVSlider.value):"";
					objVSlider.value = valor.valueOf();
					break;
				case "mx.controls::HSlider":
					var objHSlider:HSlider = objeto.valueOf();
					debug?debugAlert(objeto,valor,objHSlider.value):"";
					objHSlider.value = valor.valueOf();	
					break;
				case "mx.controls::VScrollBar":
					var objVScrollBar:VScrollBar = objeto.valueOf();
					debug?debugAlert(objeto,valor,objVScrollBar.scrollPosition):"";
					objVScrollBar.scrollPosition = valor.valueOf();
					break;
				case "mx.controls::HScrollBar":
					var objHScrollBar:HScrollBar = objeto.valueOf();
					debug?debugAlert(objeto,valor,objHScrollBar.scrollPosition):"";
					objHScrollBar.scrollPosition = valor.valueOf();
					break;
				case "mx.controls::ButtonBar":
					var objButtonBar:ButtonBar = objeto.valueOf();
					debug?debugAlert(objeto,valor,objButtonBar.selectedIndex):"";
					objButtonBar.selectedIndex = valor.valueOf();
					break;
				case "mx.controls::ToggleButtonBar":
					var objToggleButtonBar:ToggleButtonBar = objeto.valueOf();
					debug?debugAlert(objeto,valor,objToggleButtonBar.selectedIndex):"";
					objToggleButtonBar.selectedIndex = valor.valueOf();
					break;
				case "mx.controls::CheckBox":
					var objCheckBox:CheckBox = objeto.valueOf();
					debug?debugAlert(objeto,valor,objCheckBox.selected):"";
					objCheckBox.selected = valor;
					break;
				case "mx.controls::PopUpButton":
					var objPopUpButton:PopUpButton = objeto.valueOf();
					debug?debugAlert(objeto,valor,objPopUpButton.selectedField):"";
					objPopUpButton.selectedField = valor.valueOf();
					break;
				case "mx.controls::RadioButton":
					var objRadioButton:RadioButton = objeto.valueOf();
					debug?debugAlert(objeto,valor,objRadioButton.selectedField):"";
					objRadioButton.selected = valor.valueOf();	
					break;
				case "mx.controls::RadioButtonGroup":
					var objRadioButtonGroup:RadioButtonGroup = objeto.valueOf();
					debug?debugAlert(objeto,valor,objRadioButtonGroup.selectedValue):"";
					objRadioButtonGroup.selectedValue = valor.valueOf();	
					break;
				case "mx.controls::DateChooser":
					var objDateChooser:DateChooser = objeto.valueOf();
					debug?debugAlert(objeto,valor,objDateChooser.selectedDate):"";
					objDateChooser.selectedDate = valor.valueOf();	
					break;
				case "mx.controls::DateField":
					var objDateField:DateField = objeto.valueOf();
					debug?debugAlert(objeto,valor,objDateField.selectedDate):"";
					objDateField.selectedDate = valor.valueOf(); 
					break;
				case "mx.controls::Label":
					var objLabel:Label = objeto.valueOf();
					debug?debugAlert(objeto,valor,objLabel.text):"";
					objLabel.text = valor.valueOf();
					break;
				case "mx.controls::RichTextEditor":
					var objRichTextEditor:RichTextEditor = objeto.valueOf();
					debug?debugAlert(objeto,valor,objRichTextEditor.htmlText):"";
					objRichTextEditor.htmlText = valor.valueOf();
					break;
				case "mx.controls::Text":
					var objText:Text = objeto.valueOf();
					debug?debugAlert(objeto,valor,objText.text):"";
					objText.text = valor.valueOf();
					break;
				case "mx.controls::TextArea":
					var objTextArea:TextArea = objeto.valueOf();
					debug?debugAlert(objeto,valor,objTextArea.text):"";
					objTextArea.text = valor.valueOf();
					break;
				case "mx.controls::DataGrid":
					var objDataGrid:DataGrid = objeto.valueOf();
					debug?debugAlert(objeto,valor,objDataGrid.dataProvider):"";
					objDataGrid.dataProvider = valor.valueOf();
					break;
												
					
				default:
					break;
			}
			return true;
		}
		
		
		/*
		*	Muestra los errores de captura cuando se mando ejecutar la funcion de asignar valor
		*/
		public function debugAlert(objeto:Object,valor:Object,tipo:Object,infoExtra:String=""):String
		{
			var salida:String = "El tipo de valor requerido en "+objeto.id+" "+objeto.toLocaleString()+" es "+getQualifiedClassName(tipo)+" y el valor que diste es "+getQualifiedClassName(valor)+" "+infoExtra;
			Alert.show(salida);
			return salida;
		}
		
		/*
		*	Todo combobox, y lista deben tener un indice llamado label que es lo que se mostrara al usuario
		*	En caso de no tenerlo se regresa un false
		*	arreglo - Array, que es el DataProvider de un elemento tipo lista o combobox
		*/
		public function tieneLabels(arreglo:Array):Boolean
		{
			for(var i:String in arreglo)
			{
				if(arreglo[i].hasOwnProperty("label"))
					return true;
			}
			return false;
		}
		
		/*
		*	Se ingresa un objeto tipo lista, y el valor que va a contener en caso de no tener labels
		*	objeto - Dataprovider de una lista
		*	valor - valor es un arreglo que se igualara a la lista
		*	campoLabel - En caso de no tener un label se asignara este campo
		*/
		public function listaValor(objeto:Object,valor:Object,campoLabel:String=""):void
		{
			if(getQualifiedClassName(valor)=="Array" || getQualifiedClassName(valor)=="ArrayCollection")
			{
				if(tieneLabels(valor as Array))
				{
					objeto.dataProvider = valor;
				}
				else
				{
					objeto.dataProvider = arrayLabel(valor,"\t",null,campoLabel);
				}
			}
			else
			{
				if(!valor)
					objeto.dataProvider = new ArrayCollection();
				else
					asignaDataProvider(objeto,valor);
			}
		}
		
		/*
		*	A un objeto de tipo datagrid,combobox o lista, se le asigna un valor y el se fija si le faltan labels
		* 	o si el campo data no esta definido
		*/
		public function asignaDataProvider(objeto:Object,valor:Object):void
		{
					var entre:Boolean = false;	
					var arrCombo:ArrayCollection;
					var estado:int = 0;
					var i:int;
					if(getQualifiedClassName(valor)=="Object")
						if(valor.hasOwnProperty("label") && valor.hasOwnProperty("data"))
							estado = 1;
						else if(valor.hasOwnProperty("data"))
							estado = 2;
						else if(valor.hasOwnProperty("label"))
							estado = 3;
						else
							estado = 4;
					
					switch(estado)
					{
						case 0:
								for (i=0 ; i < objeto.dataProvider.length; i++) 
								{
    								if ( objeto.dataProvider[i].data == valor.valueOf() || objeto.dataProvider[i].label == valor.valueOf() ) 
    								{
      									objeto.selectedIndex = i;
      									entre=true;
      									break;
    								}
    							}
    							if(!entre)
    							{
    								objeto.dataProvider.addItem({label:valor, data:valor});
    								objeto.selectedIndex = objeto.dataProvider.length-1;
    							}
    						break;
						case 1:
								for (i=0 ; i < objeto.dataProvider.length; i++) 
								{
    								if ( objeto.dataProvider[i].data == valor["data"].valueOf() || objeto.dataProvider[i].label == valor["label"].valueOf())
    								{
      									objeto.selectedIndex = i;
      									entre=true;
      									break;
    								}
    							}
    							if(!entre)
    							{
									objeto.dataProvider.addItem({label:valor["label"], data:valor["data"]});
    								objeto.selectedIndex = objeto.dataProvider.length-1;
    							}
    						break;
						case 2:
								for (i=0 ; i < objeto.dataProvider.length; i++) 
								{
    								if ( objeto.dataProvider[i].data == valor["data"].valueOf()) 
    								{
      									objeto.selectedIndex = i;
      									entre=true;
      									break;
    								}
    							}
    							if(!entre)
    							{
									objeto.dataProvider.addItem( {label:valor["data"], data:valor["data"]} );
    								objeto.selectedIndex = objeto.dataProvider.length-1;
    							}
    						break;
						case 3:
								for (i=0 ; i < objeto.dataProvider.length; i++) 
								{
    								if ( objeto.dataProvider[i].label == valor["label"]) 
    								{
      									objeto.selectedIndex = i;
      									entre=true;
      									break;
    								}
    							}
    							if(!entre)
    							{
									objeto.dataProvider.addItem( {label:valor["label"], data:valor["label"]} );
    								objeto.selectedIndex = objeto.dataProvider.length-1;
    							}
    						break;
					}
		}
		
		
		/*
		 *	Si tenemos un arreglo con los nombres de los campos de una forma, este arreglo llenara la forma con los
		 * campos especificados en el objeto, similar a asignarAJAP 
		 */
		public function formaLlenar(contenedor:Object,objeto:Object):void
		{
			var arrControles:Array = contenedor.getChildren();
			for(var i:int=0;i<arrControles.length;i++)
				if(objeto.hasOwnProperty(arrControles[i].id))
				{
					asignarValor(arrControles[i],objeto[arrControles[i].id]);
				}
			
		}
			
		
		/*
		*	Crea una forma a partir de un objeto, similar a catalogos
		*	objeto - Cada atributo de este objeto sera convertido en un campo
		*	x - posicion en X donde se mostrara
		*	y - posicion en y donde se mostrara
		*	mostrar - Si sera visible
		*/
		public function objeto2Forma(objeto:Object,x:int=0,y:int=0,mostrar:Boolean=false):DisplayObject
		{
			var arrTipos:Array = objetoInfo(objeto);
			var arrCampos:Array = new Array();
			var canvas:Canvas = new Canvas();
			var posX:int=0,posY:int=0;
			for(var indice:String in arrTipos)
			{
				var tipo:String = arrTipos[indice];
				switch(tipo)
				{
					case "String":
								arrCampos[indice+"Label"] = new Label();
								arrCampos[indice+"Label"].text = indice;
								arrCampos[indice+"Label"].x = 0;
								arrCampos[indice+"Label"].y = posY;
								arrCampos[indice+"Label"].width = 70;
								arrCampos[indice] = new TextInput();
								var validacion:NumberValidator = new NumberValidator();
								validacion.source = arrCampos[indice];
								arrCampos[indice].id = indice;
								arrCampos[indice].x = arrCampos[indice+"Label"].width;
								arrCampos[indice].y = posY;
								break;
					case "Number":
								arrCampos[indice+"Label"] = new Label();
								arrCampos[indice+"Label"].text = indice;
								arrCampos[indice+"Label"].x = 0;
								arrCampos[indice+"Label"].y = posY;
								arrCampos[indice+"Label"].width = 70;
								arrCampos[indice] = new TextInput();
								arrCampos[indice].id = indice;
								arrCampos[indice].x = arrCampos[indice+"Label"].width;
								arrCampos[indice].y = posY;
								break;
				}
				posY+=30;
			}
			for(indice in arrCampos)
			{
				canvas.addChild(arrCampos[indice]);
			}
			canvas.id = "canvas"+getQualifiedClassName(objeto);
			canvas.x = x;
			canvas.y = y;
			if(mostrar)
				return objPadre.addChild(canvas);
			return canvas;
		}

		/*
		 * Verificar si el objero ingresado es contenedor o no
		 * 
		 */
		public function esContenedor(contenedor:Object):Boolean
		{
			if(getQualifiedSuperclassName(contenedor).indexOf("ontainer")>=0 ||getQualifiedClassName(contenedor).indexOf("ontainer")>=0 ||getQualifiedSuperclassName(contenedor).indexOf("pplication")>=0 ||getQualifiedClassName(contenedor).indexOf("pplication")>=0)
				return true;
				return false;
		}		

		
		
		public function set destination(destination:String):void
		{
			remoteObject.destination = this._destination = destination;
		}
		
		
		/**
		 * Convierte un objeto en un array, tomando los atributos como indices del arreglo
		 */
		public function objeto2Array(objeto:Object):Array
		{
			var arrSalida:Array = new Array();
			var propiedades:String = varDump(objeto,false);
			var arreglo:Array = propiedades.split("\n  ");
			for(var i:int=1;i<arreglo.length;i++)
			{
				var elemento:String = arreglo[i];
				var arrVar:Array = elemento.split(" = ");
				var campo:String = arrVar[0];
				if(campo!="mx_internal_uid")
				{
					var valor:String = arrVar[1];
					valor = valor.replace("\"","");
					arrSalida[arrVar[0]] = valor.replace("\"","");
				}
			}
			return arrSalida;
		}
		
		
		public function arrayObject2array(object:Object):Array
		{
			var arrSal:Array = null;
			if(object is Array)
			{
				arrSal = new Array();
				var arrCol:Array = Array(object);
				for each(var obj:Object in arrCol)
				{
					var arr:Array = new Array();
					for(var i:String in obj)
					{
						arr[i] = new Array();
						for(var j:String in obj[i])
						{
							arr[i][j] = obj[i][j];
						}
					}						
					arrSal.push(arr);
				}  
			}
			return arrSal;
		}
		

		/**
		 * Manda un alert de un objeto con la descripcion de todas sus caracteristicas
		 */
		public function varDump(objeto:Object,alerta:Boolean=true):String
		{
			var salida:String = ObjectUtil.toString(objeto);
			if(alerta)
				Alert.show(salida);
			return salida;
		}
		
		/**
		 * Regresa informacion muy detallada de un objeto, si necesitamos saber cuanto vale cada atributo del objeto
		 * esta es la opcion
		 */
		public function objetoInfo(objeto:Object,debug:Boolean=false,mostrarXML:Boolean=false):Array 
		{ 
            var classInfo:XML = describeType(objeto);
            var valores:String = "";
            var arrTipos:Array = new Array();
            if(mostrarXML)
            	valores += classInfo.toString();
            valores += "Class " + classInfo.@name.toString() + "\n";
            for each (var v:XML in classInfo..variable) 
            {
            	arrTipos[v.@name] = v.@type ;
                valores += "Variable " + v.@name + "=" + objeto[v.@name] + 
                    " (" + v.@type + ")\n";
            }
            for each (var a:XML in classInfo..accessor) 
            {
                if (a.@access == 'writeonly') 
                {
                    valores += "Property " + a.@name + " (" + a.@type +")\n";
                }
                else 
                {
                    valores += "Property " + a.@name + "=" + 
                        objeto[a.@name] +  " (" + a.@type +")\n";
                }
            } 
            for each (var m:XML in classInfo..method) 
            {
                valores += "Method " + m.@name + "():" + m.@returnType + "\n";
            }
            if(debug)
            	Alert.show(valores);
            return arrTipos;
        }
        
        
		public virtual function inserts(objeto:Object,guardarEn:String=""):*
		{
		
		}
		
		public virtual function getObject(tipo:String):*
    	{
    		
     	}
        
        /**
        * Pide un objeto a PHP
        */
        public function objetoPedir(tipo:Object):Object
        {
        	trabajando = true;
        	var indice:String;
        	var objSalida:Object;
        	switch(getQualifiedClassName(tipo))
        	{
        		case "String":
        						if(objetosCreados[tipo])
        							return objetosCreados[tipo];
        						objSalida = getObject(tipo.toString());
        						break;
        		case "Array":
        						for(indice in tipo)
        							objSalida = getObject(tipo[indice]);
        						break;
        		default: 
        				        for(indice in tipo)
        							objSalida = getObject(tipo[indice]);
        						break;
        	}
        	
        	if(getQualifiedClassName(objSalida)!="mx.rpc::AsyncToken")
        		return objSalida;
        	else
        	{
        		tokenEnEspera = objSalida as AsyncToken;
        		return tokenEnEspera;
        	}
        }
        
        /**
        * Crea un objeto de tipo base de datos
        */
        public function objetoCrear(tipo:String):Object
        {
        	if(objetosCreados[tipo])
        	{
        		return array2Object(ObjectUtil.copy(objetosCreados[tipo]));
        	}
        	else
        	{
				if(trabajando)
				{
					return "Error: El objeto se esta creando checar el estatus de trabajando";
				}
				else
				{
					objetoPedir(tipo);
					return "Error: Se creara objeto verificar el esattus de trabajando";
				}
        	}
        }
        
        /** Sirve para esperar la respuesta dels ervidor
        */
        public function esperaToken(tiempo:Number=0):Object
        {
        	var salida:Object = tokenEnEspera.result;
        	if(salida==null && tiempo > 0 )
        	{
        		return esperaToken(--tiempo);
        	}
        	else
        	{
        		if(salida==null)
        			return esperaToken(1000);
        		else
        			return salida;
        	}
        }
        
        /**
        * Queda en espera de un objeto
        */
        private function listenerPedirObjeto(event:ResultEvent):void
        {
        	var objeto:Object = array2Object(event.result);
			objetosCreados[event.result["nombreClase"]] = objeto;
			trabajando = false;
        }
        
        public function objetoCargar(event:Object):void
        {
        	var objeto:Object = array2Object(event);
			objetosCreados[event["nombreClase"]] = objeto;
			trabajando = false;
        }
        
        
        /**
        * Asigna la propiedad label a un objeto
        */
        public function objetoLabel(objeto:Object,delimitador:String="\t",orden:Array=null,campoLabel:String=""):Array
        {
        	var tipo:String = getQualifiedClassName(objeto);
        	if(tipo=="DynamicClase" || tipo=="Array")
        	{
        		if(campoLabel)
        		{
        			objeto["label"] = objeto[campoLabel];
        		}
        		else
        		{
        			objeto["label"] = array2String(objeto,delimitador,orden);
        		}
        		return objeto2Array(objeto);
        	}
        	else
        	{
        		var arreglo:Array = objeto2Array(objeto);
        		if(campoLabel)
        		{
        			arreglo["label"] = arreglo[campoLabel];
        		}
        		else
        		{
        			arreglo["label"] = array2String(objeto,delimitador,orden);
        		}
				return arreglo;
        	} 
        }
        
        /**
        * Regresa si el arreglo es multidimensional
        */
        public function arrayMultiDim(arreglo:Array):Boolean
        {
        	if(arreglo.length>0)
        	{
        		if(arreglo[0])
        		{
        			if(getQualifiedClassName(arreglo[0])=="Array")
        				return true;
        			else
        				return false;
        		}
        		else
        			return false;
        	}
        	else
        		return false;
        }
        
        /**
        * Agrega un elemento o varios a una lista
        * objeto - Es la lista a la cual se agregara un elemento
        * valor - arreglo con los indices a agregar, de preferencia q traigan label y data
        */
        public function listaAdd(objetoLista:Object,valor:Object,indice:String=""):void
        {
        	if(objetoLista.hasOwnProperty("dataProvider"))
        	{
        		var arrValor:Array = new Array();
        		var arreglo:Array = new Array();
        		var arrTemp:Array = new Array();
        		if(objetoLista.dataProvider)
        		{
        			arreglo = objetoLista.dataProvider.toArray();
        		}
        		arrValor = arrayLabel(valor);
        		if(arrayMultiDim(arrValor))
        		{
        			for(var i:String in arrValor)
        			{
        				if(indice=="")
        				{
        					arreglo[arreglo.length] = arrValor[i];
        				}
        				else
        				{
        					arrTemp = arrValor[i];
        					arrTemp[indice] = arreglo.length + 1;
        					arreglo[arreglo.length] = arrTemp;
        				}
        			}
        		}
        		else
        		{
        			if(indice=="")
    				{
    					arreglo[arreglo.length] = arrValor;
    				}
    				else
    				{
    					arrValor[indice] = arreglo.length + 1;
    					arreglo[arreglo.length] = arrValor;
    				}
        		}
        		objetoLista.dataProvider = arreglo;
        	}
        }
        
        /**
        * Elimina una fila de una lista
        * objetoLista - Objeto tipo lista
        * indice - El numero del renglon a eliminar
        */
        public function listaRemove(objetoLista:Object,indice:Object=null):void
        {
        	var arrCol:ArrayCollection;
        	if(indice!=null)
        	{
	        	if(getQualifiedClassName(indice)=="int" || getQualifiedClassName(indice)=="Number")
	        	{
	        		arrCol = objetoLista.dataProvider;
					arrCol.removeItemAt(indice as int);
					objetoLista.dataProvider = arrCol;
	        	}
	        }
	        else
	        {
	        	if(objetoLista.dataProvider)
	        	{
					arrCol = objetoLista.dataProvider;
					if(objetoLista.selectedIndex>=0)
					{
						arrCol.removeItemAt(objetoLista.selectedIndex);
						objetoLista.dataProvider = arrCol;
					}
	        	}
	        }
        }
        
        
        /**
        * Deja en blanco una lista
        * objetoLista
        */
        public function listaLimpiar(objetoLista:Object):void
        {
        	objetoLista.dataProvider = null;
        }
        
        public function listaChange(objetoLista:Object,valorAntes:Object,valorDespues:Object):void
        {
        }
        
        /**
        * Agrega un label a un arreglo
        */
        public function arrayLabel(objeto:Object,delimitador:String="\t",orden:Array=null,campoLabel:String=""):Array
        {
        	var objetoSalida:Array = new Array();
        	for(var indice:String in objeto)
        	{
        		if(campoLabel)
        			objetoSalida[indice] = 	objetoLabel(objeto[indice],delimitador,orden,campoLabel);        			
        		else
        			objetoSalida[indice] = 	objetoLabel(objeto[indice],delimitador,orden);
        	}
        	return objetoSalida;
        }
        
        /**
        * Convierte un arreglo a un string poniendo como delimitador el caracter seleccionado en els egundo parametro
        */
        public function array2String(objeto:Object,delimitador:String="\t",orden:Array=null):String
        {
        	var salida:String = "";
        	var indice:String = "";
        	var coma:String = "";
        	if(orden!=null)
        	{
				for(indice in orden)
				{
					salida += coma + objeto[orden[indice]];
					coma = delimitador;
				}
        	}
			else
			{
				var arr:Array = objeto2Array(objeto);
				var arreglo:Array = camposNoVacios(arr);
				for(indice in arreglo)
				{
					salida += coma + arreglo[indice];
					coma = delimitador;
				}
			}
			return salida;
        }
        
        /**
        * Agrega un indice alfanumerico con un valor a un arreglo
        * arreglo
        * propiedad - nombre del indice
        * valor - Cuanto vale el nuevo indice
        */
        public function arrayAddProperty(arreglo:Object,propiedad:String,valor:String):Object
		{
			var i:int;
			var arrTmp:Array
			if( getQualifiedClassName(arreglo)=="mx.utils::ObjectProxy" || getQualifiedClassName(arreglo)=="Object" )
			{
				arreglo = this.objeto2Array(arreglo) as Array;
			}
			if(getQualifiedClassName(arreglo)=="Array" || getQualifiedClassName(arreglo)=="DynamicClase" )
			{
				var varArr:Array = arreglo as Array;
				if(arrayMultiDim(varArr))
				{
					for(i=0;i<varArr.length;i++)
					{
						arrTmp = varArr[i];
						arrTmp[propiedad] = valor;
						varArr[i] = arrTmp;
					}
				}
				else
				{
					varArr[propiedad] = valor;
				}
				return varArr;
			}
			else
			{
				var varArrCol:ArrayCollection = arreglo as ArrayCollection;
				for(i=0;i<varArrCol.length;i++)
				{
					arrTmp = varArrCol[i];
					arrTmp[propiedad] = valor;
					varArrCol[i] = arrTmp;
				}
				return varArrCol;
			}
		}
        
        /**
        * En un arreglo checa que atributos no van en blanco y regresa un arreglo con ellos
        */
        public function camposNoVacios(arreglo:Array):Array
        {
        	var arrSalida:Array = new Array();
        	
        	for(var indice:String in arreglo)
        		if(arreglo[indice]!="" && indice!="nombreClase" && arreglo[indice]!=null)
        			arrSalida[indice] = arreglo[indice];
        	return arrSalida;
        }
        
        
        /**
        * Graba todos los elementos de una lista en base de datos
        */
        public function listaGuardar(lista:Object):void
        {
        	var arr:ArrayCollection = lista.dataProvder;
        	for(var indice:String in arr)
        	{
        		if(lista.name!="")
        		{
        			arr[indice]["nombreClase"] = lista.name;
        			inserts(arr[indice]);
        		}
        		else
        			inserts(arr[indice]);
        	}
        }
	}
}
